
package com.hlkj.pay.app.merchant.impl;

import com.hlkj.framework.common.pojo.CommonResult;
import com.hlkj.framework.common.util.collection.CollectionUtils;
import com.hlkj.framework.common.util.json.JsonUtils;
import com.hlkj.pay.common.CommonResultCode;
import com.hlkj.pay.dto.merchant.ProviderChannelFeeConfigList;
import com.hlkj.pay.dto.provider.DefaultFeeConfig;
import com.hlkj.pay.dto.provider.SeniorFeeConfig;
import com.hlkj.pay.dto.provider.StepFeeConfig;
import com.hlkj.pay.enums.CommonEnum;
import com.hlkj.pay.enums.PayEnums;
import com.hlkj.pay.infrastructure.model.pay.PayChannelDO;
import com.hlkj.pay.infrastructure.model.pay.PayWayDO;
import com.hlkj.pay.infrastructure.model.pay.ProviderChannelFeeConfigDO;
import com.hlkj.pay.service.pay.IPayChannelService;
import com.hlkj.pay.service.pay.IPayWayService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author HlpayTeam
 * @date 2024/09/25 13:09
 */
@Slf4j
@RequiredArgsConstructor
@Service
public class MerchantFeeParamsCheck {

    private final IPayWayService payWayService;

    private final IPayChannelService payChannelService;

    /**
     * 参数校验
     * 
     * @param providerChannelFeeConfigList
     * @param providerChannelFeeConfigReqList
     * @return
     */

    public CommonResult<Void> submitCheckParams(List<ProviderChannelFeeConfigDO> providerChannelFeeConfigList, List<ProviderChannelFeeConfigList> providerChannelFeeConfigReqList) {
        if (CollectionUtils.isEmpty(providerChannelFeeConfigList)) {
            // return CommonResult.error(CommonResultCode.PARAMETER_MISSING.getCode(),
            // "服务商费率参数没有配置,请先配置");
            return CommonResult.success();
        }
        List<String> errorMsgList = new ArrayList<>();
        // 按照支付方式进行分组 比对通道的数据
        Map<String, List<ProviderChannelFeeConfigDO>> channelFeeConfigMap = providerChannelFeeConfigList.stream()
                .filter(providerChannelFeeConfigDO -> CommonEnum.YES_NO_TYPE.YES.getCode().equals(providerChannelFeeConfigDO.getStatus()))
                .collect(Collectors.groupingBy(providerChannelFeeConfigDO -> providerChannelFeeConfigDO.getPayWayCode()));

        List<PayWayDO> payWayList = payWayService.queryByCodes(new ArrayList<>(channelFeeConfigMap.keySet()));

        Map<String, PayWayDO> payWayMap = payWayList.stream().collect(Collectors.toMap(payWayDO -> payWayDO.getCode(), Function.identity(), (t1, t2) -> t1));

        // 比对提交的数据和通道的数据
        for (ProviderChannelFeeConfigList providerChannelFeeConfigListReq : providerChannelFeeConfigReqList) {
            // 无效数据不需要校验
            if (CommonEnum.YES_NO_TYPE.NO.getCode().equals(providerChannelFeeConfigListReq.getStatus())) {
                continue;
            }
            List<ProviderChannelFeeConfigDO> providerChannelFeeConfigs = channelFeeConfigMap.get(providerChannelFeeConfigListReq.getPayWayCode());
            PayWayDO payWayDO = payWayMap.get(providerChannelFeeConfigListReq.getPayWayCode());
            if (CollectionUtils.isEmpty(providerChannelFeeConfigs)) {
                // errorMsgList.add(String.format("支付方式 %s 在通道中不存在,请检查", payWayDO.getName()));
                continue;
            }
            // 通道配置不存在 直接通过
            ProviderChannelFeeConfigDO providerChannelFeeConfigDO = providerChannelFeeConfigs.get(0);
            if (providerChannelFeeConfigDO == null) {
                continue;
            }

            //进件状态都是1 不做校验
            String dbKey = Key(1, providerChannelFeeConfigDO.getStepFeeType(), providerChannelFeeConfigDO.getSeniorFeeType());
            String submitKey = Key(1, providerChannelFeeConfigListReq.getStepFeeType(),
                    providerChannelFeeConfigListReq.getSeniorFeeType());
            PayChannelDO payChannelDO = payChannelService.queryByCode(providerChannelFeeConfigDO.getChannelCode());
            if (payChannelDO == null) {
                continue;
            }
            if (!dbKey.equals(submitKey)) {
                errorMsgList.add(String.format("支付方式 %s 通道%s 配置中 支持进件、阶梯费率、高级配置 分别为%s,%s,%s,提交的商户默认 支持进件、阶梯费率、高级配置 分别 为%s,%s,%s,二者必须一致,请检查", payWayDO.getName(),
                        payChannelDO.getName(), CommonEnum.YES_NO_TYPE.from(providerChannelFeeConfigDO.getApplyType()).getDesc(),
                        CommonEnum.YES_NO_TYPE.from(providerChannelFeeConfigDO.getStepFeeType()).getDesc(),
                        CommonEnum.YES_NO_TYPE.from(providerChannelFeeConfigDO.getSeniorFeeType()).getDesc(),
                        CommonEnum.YES_NO_TYPE.from(providerChannelFeeConfigListReq.getApplyType()).getDesc(),
                        CommonEnum.YES_NO_TYPE.from(providerChannelFeeConfigListReq.getStepFeeType()).getDesc(),
                        CommonEnum.YES_NO_TYPE.from(providerChannelFeeConfigListReq.getSeniorFeeType()).getDesc()));
                continue;
            }
            // 基础配置
            DefaultFeeConfig submitDefaultFeeConfigValue = providerChannelFeeConfigListReq.getDefaultFeeConfigValue();
            if (submitDefaultFeeConfigValue != null) {
                DefaultFeeConfig dbDefaultFeeConfigValue = providerChannelFeeConfigDO.getDefaultFeeConfigValue();
                if (dbDefaultFeeConfigValue != null) {
                    switch (PayEnums.FEE_TYPE.from(submitDefaultFeeConfigValue.getFeeType())) {
                        case PERCENTAGE:
                            BigDecimal rateBase = dbDefaultFeeConfigValue.getRateBase();
                            BigDecimal submitRateBase = submitDefaultFeeConfigValue.getRateBase();
                            if ((submitRateBase.compareTo(rateBase)) < 0) {
                                errorMsgList.add(String.format("支付方式 %s 基础配置 百分比费率 通道%s 配置中为%s,提交的商户默认配置为%s,必须大于通道配置,请检查", payChannelDO.getName(), payWayDO.getName(),
                                        dbDefaultFeeConfigValue.getRateBase(), submitDefaultFeeConfigValue.getRateBase()));
                            }
                            break;
                        case FIXED_VALUE:
                            BigDecimal fixedRateBase = dbDefaultFeeConfigValue.getFixedRate();
                            BigDecimal submitFixedRateBase = submitDefaultFeeConfigValue.getFixedRate();
                            if ((submitFixedRateBase.compareTo(fixedRateBase)) < 0) {
                                errorMsgList.add(String.format("支付方式 %s 基础配置 固定费率 通道%s 配置中为%s,提交的商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), payChannelDO.getName(),
                                        dbDefaultFeeConfigValue.getFixedRate(), submitDefaultFeeConfigValue.getFixedRate()));
                            }
                            break;
                        default:
                            rateBase = dbDefaultFeeConfigValue.getRateBase();
                            submitRateBase = submitDefaultFeeConfigValue.getRateBase();
                            if ((submitRateBase.compareTo(rateBase)) < 0) {
                                errorMsgList.add(String.format("支付方式 %s 基础配置 百分比费率 通道%s 配置中为%s,提交的商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), payChannelDO.getName(),
                                        dbDefaultFeeConfigValue.getRateBase(), submitDefaultFeeConfigValue.getRateBase()));
                            }
                            fixedRateBase = dbDefaultFeeConfigValue.getFixedRate();
                            submitFixedRateBase = submitDefaultFeeConfigValue.getFixedRate();
                            if ((submitFixedRateBase.compareTo(fixedRateBase)) < 0) {
                                errorMsgList.add(String.format("支付方式 %s 基础配置 固定费率 通道%s 配置中为%s,提交的商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), payChannelDO.getName(),
                                        dbDefaultFeeConfigValue.getFixedRate(), submitDefaultFeeConfigValue.getFixedRate()));
                            }
                    }
                }
            }
            if (CommonEnum.YES_NO_TYPE.YES.getCode().equals(providerChannelFeeConfigListReq.getStepFeeType())) {
                // 阶梯配置
                List<StepFeeConfig> stepFeeConfigs = providerChannelFeeConfigDO.getStepFeeConfigs();
                List<StepFeeConfig> submitStepFeeConfigs = providerChannelFeeConfigListReq.getStepFeeConfigs();
                if (CollectionUtils.isEmpty(stepFeeConfigs) && !CollectionUtils.isEmpty(submitStepFeeConfigs)) {
                    errorMsgList.add(String.format("支付方式%s 存在阶梯配置,通道%s 配置中不存在阶梯配置,请检查", payWayDO.getName(), payChannelDO.getName()));
                }
                if (!CollectionUtils.isEmpty(stepFeeConfigs) && CollectionUtils.isEmpty(submitStepFeeConfigs)) {
                    errorMsgList.add(String.format("支付方式%s 不存在阶梯配置,通道%s 配置中存在阶梯配置,请检查", payWayDO.getName(), payChannelDO.getName()));
                }
                if (!CollectionUtils.isEmpty(stepFeeConfigs)) {
                    // 服务商费率必须比渠道要高
                    Map<String, StepFeeConfig> stepFeeConfigMap = stepFeeConfigs.stream()
                            .collect(Collectors.toMap(stepFeeConfig -> stepFeeKey(stepFeeConfig), Function.identity(), (t1, t2) -> t1));
                    Map<String, StepFeeConfig> submitStepFeeConfigMap = submitStepFeeConfigs.stream()
                            .collect(Collectors.toMap(stepFeeConfig -> stepFeeKey(stepFeeConfig), Function.identity(), (t1, t2) -> t1));

                    for (String stepFeeKey : stepFeeConfigMap.keySet()) {
                        StepFeeConfig stepFeeConfig = stepFeeConfigMap.get(stepFeeKey);
                        StepFeeConfig submitStepFeeConfig = submitStepFeeConfigMap.get(stepFeeKey);
                        if (submitStepFeeConfig == null) {
                            errorMsgList.add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,通道%s 配置中存在,提交的商户默认配置不存在,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(),
                                    stepFeeConfig.getEndAmt(), payChannelDO.getName()));
                        }
                        else if (submitStepFeeConfig.getRateBase() == null) {
                            errorMsgList.add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,通道%s 配置中为%s,提交的商户默认配置为空,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(),
                                    stepFeeConfig.getEndAmt(), payChannelDO.getName(), stepFeeConfig.getRateBase()));
                        }
                        else {
                            BigDecimal rateBase = stepFeeConfig.getRateBase();
                            BigDecimal submitRateBase = submitStepFeeConfig.getRateBase();
                            if ((submitRateBase.compareTo(rateBase)) < 0) {
                                errorMsgList.add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,通道%s 配置中为%s,提交的商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(),
                                        stepFeeConfig.getEndAmt(), payChannelDO.getName(), stepFeeConfig.getRateBase(), submitStepFeeConfig.getRateBase()));
                            }
                        }
                    }
                }
            }
            if (CommonEnum.YES_NO_TYPE.YES.getCode().equals(providerChannelFeeConfigListReq.getSeniorFeeType())) {
                // 高级配置
                SeniorFeeConfig submitSeniorFeeConfigValue = providerChannelFeeConfigListReq.getSeniorFeeConfigValue();
                if (submitSeniorFeeConfigValue != null) {
                    SeniorFeeConfig dbSeniorFeeConfigValue = providerChannelFeeConfigDO.getSeniorFeeConfigValue();
                    if (dbSeniorFeeConfigValue == null) {
                        errorMsgList.add(String.format("支付方式 %s 高级配置 通道%s 配置为空,提交的商户配置存在,请检查", payWayDO.getName(), payChannelDO.getName()));
                        continue;
                    }
                    BigDecimal rateBase = dbSeniorFeeConfigValue.getProviderMinFee();
                    BigDecimal submitRateBase = submitSeniorFeeConfigValue.getProviderMinFee();
                    if ((submitRateBase.compareTo(rateBase)) < 0) {
                        errorMsgList.add(String.format("支付方式 %s 高级配置 保底 通道%s 配置中为%s,提交的商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), payChannelDO.getName(),
                                dbSeniorFeeConfigValue.getProviderMinFee(), submitSeniorFeeConfigValue.getProviderMinFee()));
                    }
                    BigDecimal fixedProviderMaxFee = dbSeniorFeeConfigValue.getProviderMaxFee();
                    BigDecimal submitProviderMaxFee = submitSeniorFeeConfigValue.getProviderMaxFee();
                    if ((submitProviderMaxFee.compareTo(fixedProviderMaxFee)) < 0) {
                        errorMsgList.add(String.format("支付方式 %s 高级配置 封顶 通道%s 配置中为%s,提交的商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), payChannelDO.getName(),
                                dbSeniorFeeConfigValue.getProviderMaxFee(), submitSeniorFeeConfigValue.getProviderMaxFee()));
                    }
                }
            }
        }
        if (!CollectionUtils.isEmpty(errorMsgList)) {
            return CommonResult.error(CommonResultCode.PARAMETER_MISSING.getCode(), JsonUtils.toJsonString(errorMsgList));
        }
        return CommonResult.success();
    }

    /**
     * 
     * @param agentFeeConfig
     * @param merchantFeeConfig
     * @return
     */
    public List<String> checkAgentAndMerchantFeeConfig(ProviderChannelFeeConfigList agentFeeConfig, ProviderChannelFeeConfigList merchantFeeConfig) {
        List<String> errorMsgList = new ArrayList<>();
        String merchantKey = Key(agentFeeConfig.getApplyType(), agentFeeConfig.getStepFeeType(), agentFeeConfig.getSeniorFeeType());
        String agentKey = Key(merchantFeeConfig.getApplyType(), merchantFeeConfig.getStepFeeType(), merchantFeeConfig.getSeniorFeeType());
        PayWayDO payWayDO = payWayService.queryByCode(agentFeeConfig.getPayWayCode());
        if (!merchantKey.equals(agentKey)) {
            errorMsgList.add(String.format("支付方式 %s 代理 配置中 支持进件、阶梯费率、高级配置 分别为%s,%s,%s,订单交易商户默认 支持进件、阶梯费率、高级配置 分别 为%s,%s,%s,二者必须一致,请检查", payWayDO.getName(),
                    CommonEnum.YES_NO_TYPE.from(agentFeeConfig.getApplyType()).getDesc(), CommonEnum.YES_NO_TYPE.from(agentFeeConfig.getStepFeeType()).getDesc(),
                    CommonEnum.YES_NO_TYPE.from(agentFeeConfig.getSeniorFeeType()).getDesc(), CommonEnum.YES_NO_TYPE.from(merchantFeeConfig.getApplyType()).getDesc(),
                    CommonEnum.YES_NO_TYPE.from(merchantFeeConfig.getStepFeeType()).getDesc(), CommonEnum.YES_NO_TYPE.from(merchantFeeConfig.getSeniorFeeType()).getDesc()));
            return errorMsgList;
        }
        // 基础配置
        DefaultFeeConfig merchantDefaultFeeConfigValue = merchantFeeConfig.getDefaultFeeConfigValue();
        if (merchantDefaultFeeConfigValue != null) {
            DefaultFeeConfig agentDefaultFeeConfigValue = agentFeeConfig.getDefaultFeeConfigValue();
            if (agentDefaultFeeConfigValue != null) {
                switch (PayEnums.FEE_TYPE.from(merchantDefaultFeeConfigValue.getFeeType())) {
                    case PERCENTAGE:
                        BigDecimal rateBase = agentDefaultFeeConfigValue.getRateBase();
                        BigDecimal submitRateBase = merchantDefaultFeeConfigValue.getRateBase();
                        if ((submitRateBase.compareTo(rateBase)) < 0) {
                            errorMsgList.add(String.format("支付方式 %s 基础配置 百分比费率 代理配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), agentDefaultFeeConfigValue.getRateBase(),
                                    merchantDefaultFeeConfigValue.getRateBase()));
                        }
                        break;
                    case FIXED_VALUE:
                        BigDecimal fixedRateBase = agentDefaultFeeConfigValue.getFixedRate();
                        BigDecimal submitFixedRateBase = merchantDefaultFeeConfigValue.getFixedRate();
                        if ((submitFixedRateBase.compareTo(fixedRateBase)) < 0) {
                            errorMsgList.add(String.format("支付方式 %s 基础配置 固定费率 代理配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), agentDefaultFeeConfigValue.getFixedRate(),
                                    merchantDefaultFeeConfigValue.getFixedRate()));
                        }
                        break;
                    default:
                        rateBase = agentDefaultFeeConfigValue.getRateBase();
                        submitRateBase = merchantDefaultFeeConfigValue.getRateBase();
                        if ((submitRateBase.compareTo(rateBase)) < 0) {
                            errorMsgList.add(String.format("支付方式 %s 基础配置 百分比费率 代理配置配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), agentDefaultFeeConfigValue.getRateBase(),
                                    merchantDefaultFeeConfigValue.getRateBase()));
                        }
                        fixedRateBase = agentDefaultFeeConfigValue.getFixedRate();
                        submitFixedRateBase = merchantDefaultFeeConfigValue.getFixedRate();
                        if ((submitFixedRateBase.compareTo(fixedRateBase)) < 0) {
                            errorMsgList.add(String.format("支付方式 %s 基础配置 固定费率 代理配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), agentDefaultFeeConfigValue.getFixedRate(),
                                    merchantDefaultFeeConfigValue.getFixedRate()));
                        }
                }
            }
        }
        if (CommonEnum.YES_NO_TYPE.YES.getCode().equals(agentFeeConfig.getStepFeeType())) {
            // 阶梯配置
            List<StepFeeConfig> agentStepFeeConfigs = agentFeeConfig.getStepFeeConfigs();
            List<StepFeeConfig> merchantStepFeeConfigs = merchantFeeConfig.getStepFeeConfigs();
            if (CollectionUtils.isEmpty(agentStepFeeConfigs) && !CollectionUtils.isEmpty(merchantStepFeeConfigs)) {
                errorMsgList.add(String.format("支付方式%s 代理配置中不存在阶梯配置,订单交易配置中存在阶梯配置,请检查", payWayDO.getName()));
            }
            if (!CollectionUtils.isEmpty(agentStepFeeConfigs) && CollectionUtils.isEmpty(merchantStepFeeConfigs)) {
                errorMsgList.add(String.format("支付方式%s 代理配置中存在阶梯配置,订单交易配置中不存在阶梯配置,请检查", payWayDO.getName()));
            }
            if (!CollectionUtils.isEmpty(agentStepFeeConfigs)) {
                // 服务商费率必须比渠道要高
                Map<String, StepFeeConfig> stepFeeConfigMap = agentStepFeeConfigs.stream()
                        .collect(Collectors.toMap(stepFeeConfig -> stepFeeKey(stepFeeConfig), Function.identity(), (t1, t2) -> t1));
                Map<String, StepFeeConfig> submitStepFeeConfigMap = merchantStepFeeConfigs.stream()
                        .collect(Collectors.toMap(stepFeeConfig -> stepFeeKey(stepFeeConfig), Function.identity(), (t1, t2) -> t1));

                for (String stepFeeKey : stepFeeConfigMap.keySet()) {
                    StepFeeConfig stepFeeConfig = stepFeeConfigMap.get(stepFeeKey);
                    StepFeeConfig submitStepFeeConfig = submitStepFeeConfigMap.get(stepFeeKey);
                    if (submitStepFeeConfig == null) {
                        errorMsgList
                                .add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,代理配置中存在,订单交易商户默认配置不存在,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(), stepFeeConfig.getEndAmt()));
                    }
                    else if (submitStepFeeConfig.getRateBase() == null) {
                        errorMsgList.add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,代理配置中为%s,订单交易商户默认配置为空,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(),
                                stepFeeConfig.getEndAmt(), stepFeeConfig.getRateBase()));
                    }
                    else {
                        BigDecimal rateBase = stepFeeConfig.getRateBase();
                        BigDecimal submitRateBase = submitStepFeeConfig.getRateBase();
                        if ((submitRateBase.compareTo(rateBase)) < 0) {
                            errorMsgList.add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,代理配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(),
                                    stepFeeConfig.getEndAmt(), stepFeeConfig.getRateBase(), submitStepFeeConfig.getRateBase()));
                        }
                    }
                }
            }
        }
        if (CommonEnum.YES_NO_TYPE.YES.getCode().equals(agentFeeConfig.getSeniorFeeType())) {
            // 高级配置
            SeniorFeeConfig merchantSeniorFeeConfigValue = merchantFeeConfig.getSeniorFeeConfigValue();
            if (merchantSeniorFeeConfigValue != null) {
                SeniorFeeConfig agentSeniorFeeConfigValue = agentFeeConfig.getSeniorFeeConfigValue();
                if (agentSeniorFeeConfigValue == null) {
                    errorMsgList.add(String.format("支付方式 %s 高级配置 代理配置为空,订单交易商户配置存在,请检查", payWayDO.getName()));
                    return errorMsgList;
                }
                BigDecimal rateBase = agentSeniorFeeConfigValue.getProviderMinFee();
                BigDecimal submitRateBase = merchantSeniorFeeConfigValue.getProviderMinFee();
                if ((submitRateBase.compareTo(rateBase)) < 0) {
                    errorMsgList.add(String.format("支付方式 %s 高级配置 保底 代理配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), agentSeniorFeeConfigValue.getProviderMinFee(),
                            merchantSeniorFeeConfigValue.getProviderMinFee()));
                }
                BigDecimal fixedProviderMaxFee = agentSeniorFeeConfigValue.getProviderMaxFee();
                BigDecimal submitProviderMaxFee = merchantSeniorFeeConfigValue.getProviderMaxFee();
                if ((submitProviderMaxFee.compareTo(fixedProviderMaxFee)) < 0) {
                    errorMsgList.add(String.format("支付方式 %s 高级配置 封顶 代理配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), agentSeniorFeeConfigValue.getProviderMaxFee(),
                            merchantSeniorFeeConfigValue.getProviderMaxFee()));
                }
            }
        }
        return errorMsgList;
    }
    /**
     *
     * @param providerFeeConfig
     * @param merchantFeeConfig
     * @return
     */
    public List<String> checkProviderAndMerchantFeeConfig(ProviderChannelFeeConfigDO providerFeeConfig, ProviderChannelFeeConfigList merchantFeeConfig) {
        List<String> errorMsgList = new ArrayList<>();
        String merchantKey = Key(providerFeeConfig.getApplyType(), providerFeeConfig.getStepFeeType(), providerFeeConfig.getSeniorFeeType());
        String agentKey = Key(merchantFeeConfig.getApplyType(), merchantFeeConfig.getStepFeeType(), merchantFeeConfig.getSeniorFeeType());
        PayWayDO payWayDO = payWayService.queryByCode(providerFeeConfig.getPayWayCode());
        if (!merchantKey.equals(agentKey)) {
            errorMsgList.add(String.format("支付方式 %s 服务商 配置中 支持进件、阶梯费率、高级配置 分别为%s,%s,%s,订单交易商户默认 支持进件、阶梯费率、高级配置 分别 为%s,%s,%s,二者必须一致,请检查", payWayDO.getName(),
                    CommonEnum.YES_NO_TYPE.from(providerFeeConfig.getApplyType()).getDesc(), CommonEnum.YES_NO_TYPE.from(providerFeeConfig.getStepFeeType()).getDesc(),
                    CommonEnum.YES_NO_TYPE.from(providerFeeConfig.getSeniorFeeType()).getDesc(), CommonEnum.YES_NO_TYPE.from(merchantFeeConfig.getApplyType()).getDesc(),
                    CommonEnum.YES_NO_TYPE.from(merchantFeeConfig.getStepFeeType()).getDesc(), CommonEnum.YES_NO_TYPE.from(merchantFeeConfig.getSeniorFeeType()).getDesc()));
            return errorMsgList;
        }
        // 基础配置
        DefaultFeeConfig merchantDefaultFeeConfigValue = merchantFeeConfig.getDefaultFeeConfigValue();
        if (merchantDefaultFeeConfigValue != null) {
            DefaultFeeConfig providerDefaultFeeConfigValue = providerFeeConfig.getDefaultFeeConfigValue();
            if (providerDefaultFeeConfigValue != null) {
                switch (PayEnums.FEE_TYPE.from(merchantDefaultFeeConfigValue.getFeeType())) {
                case PERCENTAGE:
                    BigDecimal rateBase = providerDefaultFeeConfigValue.getRateBase();
                    BigDecimal submitRateBase = merchantDefaultFeeConfigValue.getRateBase();
                    if ((submitRateBase.compareTo(rateBase)) < 0) {
                        errorMsgList.add(String.format("支付方式 %s 基础配置 百分比费率 服务商配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), providerDefaultFeeConfigValue.getRateBase(),
                                merchantDefaultFeeConfigValue.getRateBase()));
                    }
                    break;
                case FIXED_VALUE:
                    BigDecimal fixedRateBase = providerDefaultFeeConfigValue.getFixedRate();
                    BigDecimal submitFixedRateBase = merchantDefaultFeeConfigValue.getFixedRate();
                    if ((submitFixedRateBase.compareTo(fixedRateBase)) < 0) {
                        errorMsgList.add(String.format("支付方式 %s 基础配置 固定费率 服务商配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), providerDefaultFeeConfigValue.getFixedRate(),
                                merchantDefaultFeeConfigValue.getFixedRate()));
                    }
                    break;
                default:
                    rateBase = providerDefaultFeeConfigValue.getRateBase();
                    submitRateBase = merchantDefaultFeeConfigValue.getRateBase();
                    if ((submitRateBase.compareTo(rateBase)) < 0) {
                        errorMsgList.add(String.format("支付方式 %s 基础配置 百分比费率 服务商配置配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), providerDefaultFeeConfigValue.getRateBase(),
                                merchantDefaultFeeConfigValue.getRateBase()));
                    }
                    fixedRateBase = providerDefaultFeeConfigValue.getFixedRate();
                    submitFixedRateBase = merchantDefaultFeeConfigValue.getFixedRate();
                    if ((submitFixedRateBase.compareTo(fixedRateBase)) < 0) {
                        errorMsgList.add(String.format("支付方式 %s 基础配置 固定费率 服务商配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), providerDefaultFeeConfigValue.getFixedRate(),
                                merchantDefaultFeeConfigValue.getFixedRate()));
                    }
                }
            }
        }
        if (CommonEnum.YES_NO_TYPE.YES.getCode().equals(providerFeeConfig.getStepFeeType())) {
            // 阶梯配置
            List<StepFeeConfig> providerStepFeeConfigs = providerFeeConfig.getStepFeeConfigs();
            List<StepFeeConfig> merchantStepFeeConfigs = merchantFeeConfig.getStepFeeConfigs();
            if (CollectionUtils.isEmpty(providerStepFeeConfigs) && !CollectionUtils.isEmpty(merchantStepFeeConfigs)) {
                errorMsgList.add(String.format("支付方式%s 服务商配置中不存在阶梯配置,订单交易配置中存在阶梯配置,请检查", payWayDO.getName()));
            }
            if (!CollectionUtils.isEmpty(providerStepFeeConfigs) && CollectionUtils.isEmpty(merchantStepFeeConfigs)) {
                errorMsgList.add(String.format("支付方式%s 服务商配置中存在阶梯配置,订单交易配置中不存在阶梯配置,请检查", payWayDO.getName()));
            }
            if (!CollectionUtils.isEmpty(providerStepFeeConfigs)) {
                // 服务商费率必须比渠道要高
                Map<String, StepFeeConfig> stepFeeConfigMap = providerStepFeeConfigs.stream()
                        .collect(Collectors.toMap(stepFeeConfig -> stepFeeKey(stepFeeConfig), Function.identity(), (t1, t2) -> t1));
                Map<String, StepFeeConfig> submitStepFeeConfigMap = merchantStepFeeConfigs.stream()
                        .collect(Collectors.toMap(stepFeeConfig -> stepFeeKey(stepFeeConfig), Function.identity(), (t1, t2) -> t1));
                
                for (String stepFeeKey : stepFeeConfigMap.keySet()) {
                    StepFeeConfig stepFeeConfig = stepFeeConfigMap.get(stepFeeKey);
                    StepFeeConfig submitStepFeeConfig = submitStepFeeConfigMap.get(stepFeeKey);
                    if (submitStepFeeConfig == null) {
                        errorMsgList
                                .add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,服务商配置中存在,订单交易商户默认配置不存在,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(), stepFeeConfig.getEndAmt()));
                    }
                    else if (submitStepFeeConfig.getRateBase() == null) {
                        errorMsgList.add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,服务商配置中为%s,订单交易商户默认配置为空,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(),
                                stepFeeConfig.getEndAmt(), stepFeeConfig.getRateBase()));
                    }
                    else {
                        BigDecimal rateBase = stepFeeConfig.getRateBase();
                        BigDecimal submitRateBase = submitStepFeeConfig.getRateBase();
                        if ((submitRateBase.compareTo(rateBase)) < 0) {
                            errorMsgList.add(String.format("支付方式 %s 阶梯配置 阶梯 %s-%s,服务商配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), stepFeeConfig.getStartAmt(),
                                    stepFeeConfig.getEndAmt(), stepFeeConfig.getRateBase(), submitStepFeeConfig.getRateBase()));
                        }
                    }
                }
            }
        }
        if (CommonEnum.YES_NO_TYPE.YES.getCode().equals(providerFeeConfig.getSeniorFeeType())) {
            // 高级配置
            SeniorFeeConfig merchantSeniorFeeConfigValue = merchantFeeConfig.getSeniorFeeConfigValue();
            if (merchantSeniorFeeConfigValue != null) {
                SeniorFeeConfig providerSeniorFeeConfigValue = providerFeeConfig.getSeniorFeeConfigValue();
                if (providerSeniorFeeConfigValue == null) {
                    errorMsgList.add(String.format("支付方式 %s 高级配置 服务商配置为空,订单交易商户配置存在,请检查", payWayDO.getName()));
                    return errorMsgList;
                }
                BigDecimal rateBase = providerSeniorFeeConfigValue.getProviderMinFee();
                BigDecimal submitRateBase = merchantSeniorFeeConfigValue.getProviderMinFee();
                if ((submitRateBase.compareTo(rateBase)) < 0) {
                    errorMsgList.add(String.format("支付方式 %s 高级配置 保底 服务商配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), providerSeniorFeeConfigValue.getProviderMinFee(),
                            merchantSeniorFeeConfigValue.getProviderMinFee()));
                }
                BigDecimal fixedProviderMaxFee = providerSeniorFeeConfigValue.getProviderMaxFee();
                BigDecimal submitProviderMaxFee = merchantSeniorFeeConfigValue.getProviderMaxFee();
                if ((submitProviderMaxFee.compareTo(fixedProviderMaxFee)) < 0) {
                    errorMsgList.add(String.format("支付方式 %s 高级配置 封顶 服务商配置中为%s,订单交易商户默认配置为%s,必须大于通道配置,请检查", payWayDO.getName(), providerSeniorFeeConfigValue.getProviderMaxFee(),
                            merchantSeniorFeeConfigValue.getProviderMaxFee()));
                }
            }
        }
        return errorMsgList;
    }

    /**
     * 查询参数校验
     *
     * @param providerChannelFeeConfigList
     * @return
     */

    public CommonResult<Void> queryCheckParams(List<ProviderChannelFeeConfigDO> providerChannelFeeConfigList, List<PayWayDO> payWayList) {
        if (CollectionUtils.isEmpty(providerChannelFeeConfigList)) {
            return CommonResult.error(CommonResultCode.PARAMETER_MISSING.getCode(), "服务商费率参数没有配置,请先配置");
        }
        List<String> errorMsgList = new ArrayList<>();
        // 按照支付方式进行分组 比对通道的数据
        Map<String, List<ProviderChannelFeeConfigDO>> channelFeeConfigMap = providerChannelFeeConfigList.stream()
                .collect(Collectors.groupingBy(providerChannelFeeConfigDO -> providerChannelFeeConfigDO.getPayWayCode()));
        Map<String, PayWayDO> payWayMap = payWayList.stream().collect(Collectors.toMap(payWayDO -> payWayDO.getCode(), Function.identity(), (t1, t2) -> t1));
        for (String payWayCode : channelFeeConfigMap.keySet()) {
            List<ProviderChannelFeeConfigDO> payWayConfigList = channelFeeConfigMap.get(payWayCode);
            // 每一个通道的配置必须一致
            Set<String> keys = new HashSet<>();
            payWayConfigList.stream().forEach(providerChannelFeeConfigDO -> keys.add(existKey(providerChannelFeeConfigDO)));
            if (keys.size() > 1) {
                List<String> channelCodes = payWayConfigList.stream().map(providerChannelFeeConfigDO -> providerChannelFeeConfigDO.getChannelCode()).collect(Collectors.toList());
                List<PayChannelDO> channelDOList = payChannelService.queryByCodes(channelCodes);
                List<String> channelNames = channelDOList.stream().map(channelDO -> channelDO.getName()).collect(Collectors.toList());
                PayWayDO payWayDO = payWayMap.get(payWayCode);
                errorMsgList.add(String.format("支付方式 %s 在通道编码为%s中 存在差异,请修改为一致", payWayDO.getName(), JsonUtils.toJsonString(channelNames)));
            }
        }
        return CommonResult.success();
    }

    public static String existKey(ProviderChannelFeeConfigDO providerChannelFeeConfigDO) {
        return String.valueOf(providerChannelFeeConfigDO.hashCode());
    }

    public static String listKey(List<StepFeeConfig> stepFeeConfigs) {
        return String.valueOf(stepFeeConfigs.hashCode());
    }

    public static String stepFeeKey(StepFeeConfig stepFeeConfig) {
        return stepFeeConfig.getStartAmt() + "_" + stepFeeConfig.getEndAmt();
    }

    public static String Key(Integer applyType, Integer stepFeeType, Integer seniorFeeType) {
        return applyType + "_" + stepFeeType + "_" + seniorFeeType;
    }

    public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1.11");
        BigDecimal b = new BigDecimal("1.12");
        System.out.println(a.compareTo(b));
    }

}
